Углублённый Python

спринт 1
Как мы учим?
8/8
Числовые типы
2/2
Булева алгебра. Условные операторы
1/1
Условные операторы и тип Bool
Последовательности
3/3
Последовательности
Циклы
Строки
Python «под капотом»
1/1
Последовательности: продолжение
2/2
Множества set()
1/1
Словари
1/1
Типы данных
1/1
Создание функций
1/1
Стандартная библиотека
2/2
Финальный проект спринта: программа-шагомер для фитнес-трекера
2/2
Как искать решение
4/4
спринт 2
Перед тем как начать
1/1
Введение
2/2
Настройка окружения: Python, IDE, venv
6/6
Настройка окружения: Git, pytest
7/7
Требования к коду
7/7
Основы отладки программ
3/3
спринт 3
Самое необходимое об ООП
8/8
Финальный проект спринта: модуль фитнес-трекера
5/5
Учебная среда
4/4
Спринт 1/18 → Тема 4/13: Последовательности → Урок 1/3

Последовательности

В программировании существует весьма востребованная задача: хранить и обрабатывать наборы данных.
Например, в фитнес-трекере может потребоваться сохранить число пройденных шагов за каждый день.
PYTHON
monday_steps = 12000
tuesday_steps = 9000
wednesday_steps = 10000
thursday_steps = 2500
friday_steps = 14000
saturday_steps = 8903
sunday_steps = 9000
Сколько же переменных придётся создать, чтобы передать данные за месяц или за год! Получится путано, громоздко и нечитаемо. Гораздо удобнее сохранить весь набор данных в одну переменную с понятным объединяющим названием.
PYTHON
week_steps = [12000, 9000, 10000, 2500, 14000, 8903, 9000]
Такие наборы данных, присвоенные одной переменной (сохранённые в один объект), называются коллекциями.

Упорядоченные и неупорядоченные последовательности

Коллекции бывают упорядоченными и неупорядоченными.
В упорядоченной коллекции к любому её элементу можно обратиться по индексу — порядковому номеру элемента; можно вывести все элементы по очереди — и порядок всегда будет один и тот же. Такие коллекции называют последовательностями. Вам знакомы списки list — это как раз последовательность.
В неупорядоченных коллекциях невозможно определить, какой элемент первый, а какой последний; они как груда детских игрушек в ящике: каждый раз вываливаются в разном порядке.
Знакомство с коллекциями начнём с последовательностей.

Виды последовательностей в Python

В Python определены несколько типов последовательностей (Sequence Type):
  • list – список;
  • tuple – кортеж;
  • range – диапазон.
Подклассы последовательностей:
  • str — строки (Text Sequence Type);
  • Бинарные списки (Binary Sequence Types):
    • bytes – байты;
    • bytearray – массивы байт;
    • memoryview – специальные объекты для доступа к внутренним данным объекта через буфер обмена памяти.
Каждый тип имеет индивидуальные особенности; но все эти коллекции не относились бы к одному виду, если бы не имели чего-то общего.

Общие особенности и методы последовательностей

В общем виде вы уже знакомы с последовательностями, а со строками и списками успешно поработали. На них и разберём те методы и свойства, которые доступны для разных типов последовательностей.

Адресация элементов

Доступ к значениям элементов последовательности можно получить через их индекс — целое число, обозначающее позицию элемента.
Отсчёт индексов начинается с нуля.
PYTHON
# Последовательность типа list (список); 
# значения элементов списка - числа типа float.
movie_ratings = [4.7, 5.0, 4.3, 3.8]

# Последовательность типа list (список); 
# значения элементов списка - строки (str)
movies = ['Матрица', 'Хакеры', 'Трон']

# Последовательность типа cтрока (str); 
# элементы этой последовательности - символы, составляющие строку
name_movie = 'Джонни Мнемоник' 

# Последовательности могут иметь элементы разных типов
# Например, одновременно элемент типа str и float
movie_info = ['Трон', 4.7]
# Элементами последовательности могут быть другие последовательности
movies_info = [['Трон', 4.7], ['Хакеры', 5.0], ['Матрица', 4.5]]

# Чтобы получить значение определённого элемента, 
# его индекс следует указать в квадратных скобках после имени последовательности.
print(movie_ratings[2])
# Вывод в терминал: 4.3

print(name_movie[0])
# Вывод в терминал: Д

# При попытке обратиться к несуществующему элементу интерпретатор вернет ошибку:
print(movies[10])
# Вывод в терминал: IndexError: list index out of range
Напечатайте элементы строки так, чтобы вывод в терминал составил слово:
PYTHON
Д
о
м
и
к
КодPYTHON

Сравнение последовательностей

При сравнении последовательностей поочерёдно сравниваются элементы с одинаковыми индексами, и при первом же различии определяется результат сравнения.
Сначала сравниваются элементы с индексом 0, и если они равны, сравниваются следующие два элемента и так далее, пока не будет исчерпана любая последовательность.
Результатом сравнения будет логическое значение True или False.
PYTHON
print([1, 2, 3] < [1, 2, 4])
# Вывод в терминал: True
Выражение, переданное в print() — истинно. В обеих последовательностях элементы с индексами 0 и 1 равны, а элемент с индексом 2 в первой последовательности меньше соответствующего элемента во второй последовательности. Сравнение этих элементов и определило результат сравнения списков.
При сравнении строк принимаются во внимание символы и их регистр. Все текстовые символы (буквы, цифры, знаки препинания, пробел, иероглифы) имеют числовую кодировку. На основе этой кодировки и происходит арифметическое сравнение строк. Заглавные и строчные буквы — это разные символы, соответственно, и кодировка у них разная.
Группы символов можно распределить по возрастанию их числовых кодов примерно так:
  • спецсимволы, знаки препинания и цифры: начинается с 32 (это числовое значение символа «пробел»);
  • латиница — заглавные буквы: A = 65;
  • латиница — строчные буквы: a = 97;
  • расширенная латиница, диакритические знаки, греческое письмо;
  • кириллица — заглавные буквы: А = 1040;
  • кириллица — строчные буквы: а = 1072;
  • и так далее.
Цифровой символ условно меньше, чем любой алфавитный символ. Алфавитный символ в верхнем регистре условно меньше, чем алфавитные символы в нижнем регистре, а кириллическая А «больше», чем a в латинице (хотя если взять оба символа из латиницы, то выражение 'A' < 'a' вернёт True).
PYTHON
print('Слон' < 'слон')
# Вывод в терминал: True
# Элемент с индексом 0 первой строки - это буквенный символ в верхнем регистре,
# его числовой код меньше той же буквы в нижнем регистре

print('1b' > 'fb')
# Вывод в терминал: False
# Элемент с индексом 0 первой строки - цифра. Её числовой код меньше, чем у букв.
Длина последовательности при сравнении не имеет значения. Как только в последовательности Python найдёт неравные элементы, их отношение и определит результат сравнения:
PYTHON
print('a' < 'ADC')
# Вывод в терминал: False

print([1, 2, 4] > [1, 2, 3, 4])
# Вывод в терминал: True
Коды символов можно найти в таблицах кодировок Unicode, а в Python эти коды можно получить через функцию ord():
PYTHON
print(ord('Ф'))
# Вывод в терминал: 1060
Важно отметить, что операторы < , >, <=, >= поддерживаются только при сравнении последовательностей одного типа и однотипных элементов в этих последовательностях.
Каким будет ответ при сравнении [10, 'one'] > ['one', 10]?
Что вернёт операция сравнения?
PYTHON
first = [15, 2, '11', 10]
second = [15, 2, '101', 17]

print(first < second)

Наименьшее и наибольшее значение элементов последовательности

В последовательностях, содержащих элементы одного типа, можно найти элементы с наименьшим и наибольшим значением. Для этого применяют встроенные методы min() и max().
PYTHON
my_string = '12345'
print(max(my_string))
# Вывод в терминал: 5

my_list = ['abc', 'Abc']
print(min(my_list))
# Вывод в терминал: Abc
«Под капотом» функции min() и max() применяются операторы > и <, поэтому ограничение на сравнение элементов разных типов действуют и для них.
PYTHON
my_list = ['123', '456', 789]
print(max(my_list))

# Вывод в терминал:
# TypeError: '>' not supported between instances of 'int' and 'str'
# Нельзя сравнивать числа со строками (даже если строки притворяются числами).

Слияние (конкатенация)

Конкатенация (объединение двух последовательностей в одну) выполняется с помощью оператора +. Объединять возможно только последовательности одного типа.
Результатом конкатенации будет новый объект.
PYTHON
first_baggage_list = ['Диван', 'Чемодан', 'Саквояж', 'Картина']

second_baggage_list= ['Корзина', 'Картонка', 'Маленькая собачонка']

full_baggage_list = first_baggage_list + second_baggage_list
print(full_baggage_list)
# Вывод в терминал: 
# ['Диван', 'Чемодан', 'Саквояж', 'Картина', 'Корзина', 'Картонка', 'Маленькая собачонка']

Повторение

Продолжая работу с арифметическими операторами — умножим последовательность на число.
Это приведёт к созданию нового объекта, в котором элементы исходной последовательности будут повторяться указанное число раз.
PYTHON
pump = 'насос' * 4
print(pump)
# Вывод в терминал: насоснасоснасоснасос

small_baggage_list = ['Корзина', 'Картонка', 'Маленькая собачонка']
double_baggage_list = small_baggage_list * 2
print(double_baggage_list)

# Вывод в терминал:
['Корзина', 'Картонка', 'Маленькая собачонка', 'Корзина', 'Картонка', 'Маленькая собачонка']

Количество элементов последовательности

Чтобы узнать количество элементов последовательности — применяют встроенный метод len().
PYTHON
movies = ['Матрица', 'Хакеры', 'Трон', 'Тихушники', 'Сеть']
print(len(movies))
# Вывод в терминал: 5
Количество элементов последовательности — пять: подсчёт элементов последовательности начинается с единицы. А индекс последнего элемента последовательности — 4: movies[4] == 'Сеть', ведь отсчёт индексов начинается с нуля.
Почти все путаются в этом.

Наличие элемента в последовательности

Python позволяет узнать, есть ли определённый элемент в последовательности. Для этого применяют оператор in, он возвращает True или False.
PYTHON
movie_ratings = [4.7, 5.0, 4.3, 3.1]
print(4.7 in movie_ratings)
# Вывод в терминал: True

name_movie = 'Джонни Мнемоник'
print('ж' in name_movie)
# Вывод в терминал: True
С помощью оператора in можно проверить и отсутствие элемента в последовательности:
PYTHON
full_baggage_list = ['Диван', 'Чемодан', 'Саквояж', 'Картина', 'Корзина', 'Картонка']

# Если собачонки нет
if 'Маленькая собачонка' not in full_baggage_list:
    # ...устраиваем скандал:
    print('— Товарищи! Где собачонка?')

Срезы

Из последовательности можно извлечь набор элементов по определённым условиям. Например, можно получить из исходной последовательности все элементы с индексами от 5 до 10 или взять каждый второй элемент последовательности.
Получившийся набор элементов будет последовательностью того же типа, что и исходная последовательность; результат такой операции называется срез.
Чтобы из последовательности sequence получить срез, в который войдут элементы, расположенные один за другим, применяют синтаксис sequence[start:end], где start и end — индексы элементов, определяющие диапазон, из которого будет взят срез.
PYTHON
name_movie = 'Джонни Мнемоник'
print(name_movie[2:10]) # В терминал будут выведены символы со 2 по 9
# Вывод в терминал: онни Мне
В этом примере в терминал вернется набор элементов с индексами, которые можно описать математическим выражением 2 ≤ index < 10: элемент с индексом 10 не будет включен в срез.
В ситуациях, когда конечный индекс указывается явно — элемент с этим индексом не включается в срез.
Для получения среза можно указать только начальный или конечный индекс элемента, тогда второй границей среза будет конец или начало исходной последовательности.
PYTHON
name_movie = 'Джонни Мнемоник'
# Взять срез с седьмого элемента и до конца последовательности
print(name_movie[7:])
# Вывод в терминал: Мнемоник

name_movie = 'Джонни Мнемоник'
# Взять срез от начала последовательности до шестого элемента (не включая шестой)
print(name_movie[:6])
# Вывод в терминал: Джонни
Чтобы получить срез из элементов, расположенных с определённым шагом, применяют синтаксис sequence[start:end:step].
PYTHON
movies = ['Матрица', 'Хакеры', 'Трон', 'Тихушники', 'Сеть']
print(movies[0:5:2])
# Вывод в терминал: ['Матрица', 'Трон', 'Сеть']
Можно получить срез, где последовательность элементов будет инвертирована. Для этого сначала указывается конечный индекс исходной последовательности, потом начальный, а шаг указывается отрицательным числом:
PYTHON
movies = ['Матрица', 'Хакеры', 'Трон', 'Тихушники', 'Сеть']
# Шаг должен иметь отрицательное зачение
print(movies[5:0:-1])
# Вывод в терминал: ['Сеть', 'Тихушники', 'Трон', 'Хакеры']

# Можно не указывать границы, а задать только отрицательное значение шага
print(movies[::-1])
# Вывод в терминал: ['Сеть', 'Тихушники', 'Трон', 'Хакеры', 'Матрица']
# Инвертирован весь список
Соберите и напечатайте словосочетание «ты программист» из строк a, b и c, используя срезы с двумя и тремя параметрами. Словосочетание должно начинаться с маленькой буквы.
КодPYTHON
Итак, базовую теорию по последовательностям вы прочли и даже закрепили некоторые знания практикой. В следующем уроке мы немного отвлечёмся от последовательностей и поговорим о циклах. А потом рассмотрим каждую последовательность отдельно.